home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / daemons / ipServer / RCS / ip.c,v < prev    next >
Encoding:
Text File  |  1990-07-09  |  62.0 KB  |  2,425 lines
  1. head     1.9;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.9
  10. date     89.10.22.12.15.17;  author nelson;  state Exp;
  11. branches ;
  12. next     1.8;
  13.  
  14. 1.8
  15. date     89.03.23.09.54.37;  author brent;  state Exp;
  16. branches ;
  17. next     1.7;
  18.  
  19. 1.7
  20. date     89.02.21.10.13.07;  author brent;  state Exp;
  21. branches ;
  22. next     1.6;
  23.  
  24. 1.6
  25. date     88.09.15.09.33.18;  author mendel;  state Exp;
  26. branches ;
  27. next     1.5;
  28.  
  29. 1.5
  30. date     88.08.26.16.34.36;  author mendel;  state Exp;
  31. branches ;
  32. next     1.4;
  33.  
  34. 1.4
  35. date     88.08.25.13.48.53;  author mendel;  state Exp;
  36. branches ;
  37. next     1.3;
  38.  
  39. 1.3
  40. date     88.08.16.11.17.08;  author mendel;  state Exp;
  41. branches ;
  42. next     1.2;
  43.  
  44. 1.2
  45. date     88.04.27.09.08.43;  author brent;  state Exp;
  46. branches ;
  47. next     1.1;
  48.  
  49. 1.1
  50. date     88.04.27.08.51.37;  author brent;  state Exp;
  51. branches ;
  52. next     ;
  53.  
  54.  
  55. desc
  56. @IP Protocol
  57. @
  58.  
  59.  
  60. 1.9
  61. log
  62. @Fix to packet header handling so the proper byte swapping is done.
  63. @
  64. text
  65. @/* 
  66.  * ip.c --
  67.  *
  68.  *      Routines to handle the IP protocol. IP packets that are received
  69.  *      from the network layer are validated and passed to the next
  70.  *      protocol layer. If the packet is fragmented, it is reassembled
  71.  *      before passed to the next layer. This file also contains
  72.  *      routines to format IP header in a packet and to send the packet to
  73.  *      the network for output. The packet may be sent in fragments if it
  74.  *      is too large for the network.
  75.  *
  76.  *    The IP protocol specification used by the routines in this file
  77.  *    is RFC 791 "Internet Protocol", Sept. 1981.
  78.  *
  79.  *
  80.  *    Based on 4.3 BSD code:
  81.  *    "@@(#)ip_input.c  7.9 (Berkeley) 3/15/88"
  82.  *    "@@(#)ip_output.c 7.9 (Berkeley) 3/15/88"
  83.  *
  84.  * Copyright 1987 Regents of the University of California
  85.  * All rights reserved.
  86.  * Permission to use, copy, modify, and distribute this
  87.  * software and its documentation for any purpose and without
  88.  * fee is hereby granted, provided that the above copyright
  89.  * notice appear in all copies.  The University of California
  90.  * makes no representations about the suitability of this
  91.  * software for any purpose.  It is provided "as is" without
  92.  * express or implied warranty.
  93.  */
  94.  
  95. #ifndef lint
  96. static char rcsid[] = "$Header: /sprite/src/daemons/ipServer/RCS/ip.c,v 1.8 89/03/23 09:54:37 brent Exp Locker: nelson $ SPRITE (Berkeley)";
  97. #endif not lint
  98.  
  99.  
  100. #include "sprite.h"
  101. #include "ipServer.h"
  102. #include "stat.h"
  103. #include "ip.h"
  104. #include "icmp.h"
  105. #include "route.h"
  106. #include "raw.h"
  107.  
  108. #include "list.h"
  109. #include "spriteTime.h"
  110. #include "fs.h"
  111.  
  112. /*
  113.  * Information needed to aid in reassembly of a datagram from its fragments. 
  114.  *
  115.  * The fragInfoList is a list of DgramFragInfo elements with one element
  116.  * per fragmented datagram. The fragments are kept on the dataList linked
  117.  * list within each DgramFragInfo element.  All fragments of a datagram
  118.  * have the same source, destination, protocol and identification fields
  119.  * in their IP headers.  If the datagram isn't reassembled before the
  120.  * timeToLive field goes to 0, all fragments are freed and the DgramFragInfo
  121.  * element is removed from the fragInfoList.
  122.  */
  123.  
  124. typedef struct {
  125.     List_Links        links;        /* Links to next and prev. items. */
  126.  
  127.     /*
  128.      * The following 4 fields in the IP header uniquely identify the datagram. 
  129.      * A fragment belongs to this datagram if all 4 fields match.
  130.      */
  131.     Net_InetAddress    source;        /* Sender of packet. */
  132.     Net_InetAddress    dest;        /* Destination of packet. */
  133.     unsigned char    protocol;    /* Protocol. */
  134.     unsigned short    ident;        /* Datagram ID. */
  135.  
  136.     int            numFrags;    /* Number of fragments. */
  137.     int            timeToLive;    /* # of seconds before the fragments 
  138.                      * are dropped. */
  139.     List_Links        dataList;    /* List head of data info elements for 
  140.                      * fragments that have arrived. */
  141. } DgramFragInfo;
  142.  
  143. /*
  144.  * List head of the list of DgramFragInfo elements.
  145.  */
  146. static List_Links    fragInfoList;
  147.  
  148.  
  149. /*
  150.  * Information about a particular fragment within a datagram.
  151.  *
  152.  * Each fragment of a datagram has one of these structures in the 
  153.  * dataList list of the DgramFragInfo element.
  154.  */
  155. typedef struct {
  156.     List_Links        links;        /* Links to next and prev. items. */
  157.     unsigned short    fragOffset;    /* Offset from the beginning of 
  158.                      * the datagram for the data in
  159.                      * this frgament. */
  160.     int            dataOffset;    /* Offset from beginning of this 
  161.                      * fragment data where usable data 
  162.                      * starts. */
  163.     int            dataLen;    /* Size in bytes of usable data. */
  164.     IPS_Packet        fragPacket;    /* Address of fragment packet. */
  165. } FragDataInfo;
  166.  
  167. /*
  168.  * Amount of time between calls to FragTimeoutHandler.
  169.  */
  170. static Time    fragTimeout = { 1, 0 };
  171.  
  172.  
  173. /*
  174.  * The protocolCallback array of functions is used to pass an IP packet
  175.  * to the next protocol layer. A higher-level protocol establishes a 
  176.  * callback using IP_SetProtocolHandler. The maximum number of callbacks is 
  177.  * 255 since the protocol field in the IP header 8 bits wide.
  178.  */
  179.  
  180. #define MAX_PROTOCOL_NUM    255
  181. static void (*protocolCallback[MAX_PROTOCOL_NUM+1])();
  182.  
  183. /*
  184.  * Forward declarations.
  185.  */
  186. static Boolean        ReassemblePacket();
  187. static ReturnStatus    ProcessOptions();
  188. static void        ForwardPacket();
  189. static DgramFragInfo    *FreeFragments();
  190. static void        SaveRoute();
  191. static void        FragTimeoutHandler();
  192. static int         CopyHeader();
  193. static Boolean        CanForward();
  194.  
  195. #ifdef DEBUG
  196. static void         TestInputProc();
  197. #endif
  198.  
  199. /*
  200.  * Macro to swap the fragOffset field.
  201.  */
  202. #define SWAP_FRAG_OFFSET_HOST_TO_NET(ptr) { \
  203.     short    *shortPtr; \
  204.     shortPtr = ((short *)&ptr->ident) + 1; \
  205.     *shortPtr = Net_HostToNetShort(*shortPtr); \
  206. } 
  207.  
  208. #define SWAP_FRAG_OFFSET_NET_TO_HOST(ptr) { \
  209.     short    *shortPtr; \
  210.     shortPtr = ((short *)&ptr->ident) + 1; \
  211.     *shortPtr = Net_NetToHostShort(*shortPtr); \
  212. } 
  213.  
  214.  
  215. /*
  216.  *----------------------------------------------------------------------
  217.  *
  218.  * IP_MemBin --
  219.  *
  220.  *    Optimize memory allocation of data structures that are dynamically
  221.  *    allocated by IP.
  222.  *
  223.  * Results:
  224.  *    None.
  225.  *
  226.  * Side effects:
  227.  *    Calls Mem_Bin.
  228.  *
  229.  *----------------------------------------------------------------------
  230.  */
  231.  
  232. void
  233. IP_MemBin()
  234. {
  235.     Mem_Bin(sizeof(DgramFragInfo));
  236.     Mem_Bin(sizeof(FragDataInfo));
  237.     Mem_Bin(sizeof(Net_IPHeader));
  238.     Mem_Bin(NET_ETHER_MAX_BYTES);
  239. }
  240.  
  241. /*
  242.  *----------------------------------------------------------------------
  243.  *
  244.  * IP_Init --
  245.  *
  246.  *    Initializes the DgramFragInfo list. This routine must be
  247.  *    called before any packets are processed. Arranges to have 
  248.  *    FragTimeoutHandler to be called at regular intervals.
  249.  *
  250.  * Results:
  251.  *    None.
  252.  *
  253.  * Side effects:
  254.  *    The DgramFragInfo list is initialized. A timeout handler is
  255.  *    created.
  256.  *
  257.  *----------------------------------------------------------------------
  258.  */
  259.  
  260. void
  261. IP_Init()
  262. {
  263.     List_Init(&fragInfoList);
  264.  
  265.     (void) Fs_TimeoutHandlerCreate(fragTimeout, TRUE, FragTimeoutHandler, 
  266.         (ClientData) 0);
  267. }
  268.  
  269.  
  270. /*
  271.  *----------------------------------------------------------------------
  272.  *
  273.  * IP_SetProtocolHandler --
  274.  *
  275.  *    Each IP packet has a protocol field that specifies the next protocol
  276.  *    layer to be called once the IP input routine has finished with
  277.  *    the datagram.  This routine establishes the procedure that will be
  278.  *    called for the given protocol.
  279.  *
  280.  *    The proc parameter should be declared as follows:
  281.  *
  282.  *    void
  283.  *    Proc(netID, packetPtr)
  284.  *        Rte_NetID    netID;
  285.  *        IPS_Packet    *packetPtr;
  286.  *    {
  287.  *    }
  288.  *
  289.  *    It is responsible for freeing the packet once it is done with it.
  290.  *
  291.  * Results:
  292.  *    None.
  293.  *
  294.  * Side effects:
  295.  *    The table of protocol callbacks is updated.
  296.  *
  297.  *----------------------------------------------------------------------
  298.  */
  299.  
  300. void
  301. IP_SetProtocolHandler(protocol, proc)
  302.     int        protocol;    /* Assigned protocol number from RFC 1010. */
  303.     void    (*proc)();    /* Procedure to call to handle packets with
  304.                  * the protocol #. */
  305. {
  306.     if (protocol < 0 || protocol > MAX_PROTOCOL_NUM) {
  307.     (void) fprintf(stderr, "Warning: IP_SetProtocolHandler: bad protocol # (%d)\n",
  308.             protocol);
  309.     return;
  310.     }
  311.     if (proc == NULL) {
  312.     (void) fprintf(stderr, 
  313.         "Warning: IP_SetProtocolHandler: NULL procedure address\n");
  314.     }
  315.     protocolCallback[protocol] = proc;
  316. }
  317.  
  318.  
  319. /*
  320.  *----------------------------------------------------------------------
  321.  *
  322.  * IP_AcceptedProtocol --
  323.  *
  324.  *    Determine if a IP protocol has a handler established for it.  This
  325.  *    is used at open time in order to deny opening an IP protocol that
  326.  *    is not implemented.
  327.  *
  328.  * Results:
  329.  *    TRUE if a callback has been installed for the protocol.
  330.  *
  331.  * Side effects:
  332.  *    None.
  333.  *
  334.  *----------------------------------------------------------------------
  335.  */
  336.  
  337. Boolean
  338. IP_AcceptedProtocol(protocol)
  339.     int        protocol;    /* Assigned protocol number from RFC 1010. */
  340. {
  341.     if (protocol < 0 || protocol > MAX_PROTOCOL_NUM) {
  342.     return(FALSE);
  343.     } else if (protocolCallback[protocol] != NULL) {
  344.     return(TRUE);
  345.     } else {
  346.     return(FALSE);
  347.     }
  348. }
  349.  
  350. /*
  351.  *----------------------------------------------------------------------
  352.  *
  353.  * IP_Input --
  354.  *
  355.  *    The main routine to deal with new IP packets from the network.
  356.  *    The packet is checked to make sure that it has the proper sizes
  357.  *    and that it has not been corrupted. The packet's destination is 
  358.  *    checked to see if it is for us or whether it needs to be forwarded
  359.  *    to the appropriate gateway. IP options processing and fragment 
  360.  *    reassembly is also initiated here.  Once processed, the packet 
  361.  *    may be handed to the next protocol layer.
  362.  *
  363.  *    Terminology: a packet is the data received from the network.
  364.  *    It may a complete IP datagram or a fragment of a datagram.
  365.  *
  366.  * Results:
  367.  *    SUCCESS    - The packet was processed successfully or was a fragment. 
  368.  *          The caller can NOT deallocate the packet memory.
  369.  *    FAILURE    - The packet was malformed or was not used. The caller 
  370.  *          must deallocate the packet memory.
  371.  *
  372.  * Side effects:
  373.  *    The fragment queue may be changed. Various statistics counters 
  374.  *    are incremented.
  375.  *
  376.  *
  377.  *    The following fields are converted from network order to host order.
  378.  *     - totalLen
  379.  *     - ident
  380.  *     - offset + flags
  381.  *     - checksum
  382.  *     - source
  383.  *     - dest
  384.  *    They must be changed back if the packet needs to be output 
  385.  *    to the network.
  386.  *
  387.  *
  388.  *----------------------------------------------------------------------
  389.  */
  390.  
  391. ReturnStatus
  392. IP_Input(netID, packetPtr)
  393.     Rte_NetID    netID;        /* ID of network interface that this packet
  394.                  * arrived on. */
  395.     IPS_Packet    *packetPtr;    /* Packet layout descriptor. */
  396. {
  397.     register Net_IPHeader    *ipHeaderPtr;
  398.     register int        headerLenInBytes;
  399.  
  400.  
  401.     stats.ip.totalRcv++;
  402.  
  403.     if (packetPtr->ipLen < sizeof(Net_IPHeader)) {
  404.     stats.ip.shortPacket++;
  405.     if (ips_Debug) {
  406.         fprintf(stderr, "IP_Input: Short packet, len=%d\n", 
  407.                 packetPtr->ipLen);
  408.     }
  409.     return(FAILURE);
  410.     }
  411.  
  412.     ipHeaderPtr =  packetPtr->ipPtr;
  413.     headerLenInBytes = ipHeaderPtr->headerLen * 4;
  414.  
  415.     if (headerLenInBytes < sizeof(Net_IPHeader)) {
  416.     stats.ip.shortHeader++;
  417.     if (ips_Debug) {
  418.         fprintf(stderr, "IP_Input: Short header, len=%d\n", 
  419.                 headerLenInBytes);
  420.     }
  421.     return(FAILURE);
  422.     }
  423.  
  424.     /*
  425.      * See if the header checksum is ok. RFC791 says the header checksum 
  426.      * is computed as if ipHeaderPtr->checksum is 0 but we recompute it with
  427.      * whatever value that's there. If the packet is good, then the sum not
  428.      * including ipHeaderPtr->checksum should be the 1's complement of 
  429.      * ipHeaderPtr->checksum and when added together (during the checksum 
  430.      * computation), they should equal 0.
  431.      */
  432.     if (Net_InetChecksum(headerLenInBytes, (Address) ipHeaderPtr) != 0) {
  433.     stats.ip.badChecksum++;
  434.     if (ips_Debug) {
  435.         fprintf(stderr, "IP_Input: Bad check sum\n");
  436.     }
  437.     return(FAILURE);
  438.     }
  439.  
  440.     ipHeaderPtr->totalLen = Net_NetToHostShort(ipHeaderPtr->totalLen);
  441.     ipHeaderPtr->ident    = Net_NetToHostShort(ipHeaderPtr->ident);
  442.     SWAP_FRAG_OFFSET_NET_TO_HOST(ipHeaderPtr);
  443.  
  444.     /*
  445.      * Change the length in the packet descriptor to the true length.
  446.      * The previous value for the length was calculated from the
  447.      * packet size from the network and that might have been too large.
  448.      */
  449.     packetPtr->ipLen = ipHeaderPtr->totalLen;
  450.  
  451.     if (ipHeaderPtr->totalLen < ipHeaderPtr->headerLen) {
  452.     stats.ip.shortLen++;
  453.     if (ips_Debug) {
  454.         fprintf(stderr, "IP_Input: Short length, len=%d\n", 
  455.                 ipHeaderPtr->totalLen);
  456.     }
  457.     return(FAILURE);
  458.     }
  459.  
  460.     if (headerLenInBytes > sizeof(Net_IPHeader)) {
  461.     /*
  462.      * Process the options that follow the basic IP header.
  463.      */
  464.     if (!ProcessOptions(headerLenInBytes, ipHeaderPtr)) {
  465.         if (ips_Debug) {
  466.         fprintf(stderr, "IP_Input: Bad options\n");
  467.         }
  468.         return(FAILURE);
  469.     }
  470.     }
  471.  
  472.     if (ips_Debug) {
  473.     (void) fprintf(stderr, 
  474.             "IP Input: %d bytes, prot %d <%x> <-- <%x,#%d> flags %x\n",
  475.             packetPtr->ipLen,
  476.             ipHeaderPtr->protocol,
  477.             Net_NetToHostInt(ipHeaderPtr->dest), 
  478.             Net_NetToHostInt(ipHeaderPtr->source),
  479.             ipHeaderPtr->ident,
  480.             ipHeaderPtr->flags);
  481.  
  482.     }
  483.  
  484.  
  485.     /*
  486.      * See if the packet is for us. If it isn't then forward it to
  487.      * the appropriate host.
  488.      */
  489.     
  490.     if (!Rte_AddrIsForUs(ipHeaderPtr->dest)) {
  491.     stats.ip.forwards++;
  492.     if (ips_Debug) {
  493.         fprintf(stderr, "IP_Input: Forwarding packet\n");
  494.     }
  495.     ForwardPacket(packetPtr);
  496.     return(FAILURE);
  497.     }
  498.  
  499.  
  500.     /*
  501.      * Fragmentation test: 
  502.      * See if this packet is a complete datagram or a fragment of one.
  503.      * If it's a fragment, then search the queue and try to reassemble the
  504.      * complete datagram.  If it's a complete datagram already, then 
  505.      * don't search the queue; even though there may be fragments for the
  506.      * datagram on the queue, let the timeout routine remove them.
  507.      */
  508.     if ((ipHeaderPtr->flags & NET_IP_MORE_FRAGS) ||
  509.     (ipHeaderPtr->fragOffset != 0)) {
  510.  
  511.     register DgramFragInfo    *fragInfoPtr;
  512.     Boolean    foundFrags;
  513.  
  514.     stats.ip.fragsRcv++;
  515.     if (ips_Debug) {
  516.         fprintf(stderr, "IP_Input: Received fragment, offset=%d\n",
  517.             ipHeaderPtr->fragOffset);
  518.     }
  519.  
  520.     foundFrags = FALSE;
  521.     LIST_FORALL(&fragInfoList, (List_Links *) fragInfoPtr) {
  522.         if ((ipHeaderPtr->ident == fragInfoPtr->ident) &&
  523.         (ipHeaderPtr->protocol == fragInfoPtr->protocol) &&
  524.         (ipHeaderPtr->source == fragInfoPtr->source) &&
  525.         (ipHeaderPtr->dest == fragInfoPtr->dest)) {
  526.         foundFrags = TRUE;
  527.         break;
  528.         }
  529.     }
  530.     if (!foundFrags) {
  531.         /*
  532.          * First fragment to arrive so there's no information yet.
  533.          * ReassemblePacket will create a list for this datagram.
  534.          */
  535.         if (ips_Debug) {
  536.         fprintf(stderr, "IP_Input: First fragment\n");
  537.         }
  538.         fragInfoPtr = (DgramFragInfo *) NULL;
  539.     }
  540.  
  541.     if (!ReassemblePacket(fragInfoPtr, packetPtr)) {
  542.         /*
  543.          * The fragment did not complete the packet.
  544.          */
  545.         return(SUCCESS);
  546.     }
  547.     if (ips_Debug) {
  548.         fprintf(stderr, "IP_Input: Fragment completes packet\n");
  549.     }
  550.     stats.ip.fragsReass++;
  551.     }
  552.  
  553.     /*
  554.      * IP Processing is now complete. Pass the datagram to the next protocol
  555.      * for additional processing.  If a callback has not been established for
  556.      * a protocol, give the datagram to the raw socket layer. 
  557.      */
  558.  
  559.     if ((ipHeaderPtr->protocol <= MAX_PROTOCOL_NUM) &&
  560.     (protocolCallback[ipHeaderPtr->protocol] != NULL)) {
  561.  
  562.      (*protocolCallback[ipHeaderPtr->protocol]) (netID, packetPtr);
  563.  
  564.     } else {
  565.     Raw_Input((int)ipHeaderPtr->protocol, ipHeaderPtr->source, 
  566.             ipHeaderPtr->dest, packetPtr);
  567.     return(FAILURE);    /* So caller will deallocate the packet. */
  568.     }
  569.     return(SUCCESS);
  570. }
  571.  
  572. /*
  573.  *----------------------------------------------------------------------
  574.  *
  575.  * FragTimeoutHandler --
  576.  *
  577.  *    Examines the fragment queue to see if any fragments should be
  578.  *    discarded because they have not been reassembled within a certain
  579.  *    amount of time. This routine is called from the Fs_Dispatch's
  580.  *    timeout mechanism.
  581.  *
  582.  * Results:
  583.  *    None.
  584.  *
  585.  * Side effects:
  586.  *    The fragment info list may be changed.
  587.  *
  588.  *----------------------------------------------------------------------
  589.  */
  590.  
  591. /*ARGSUSED*/
  592. static void
  593. FragTimeoutHandler(data, time)
  594.     ClientData    data;        /* ignored. */
  595.     Time    time;        /* ignored. */
  596. {
  597.     register DgramFragInfo    *fragInfoPtr;
  598.  
  599.     stats.ip.fragTimeouts++;
  600.  
  601.     fragInfoPtr = (DgramFragInfo *) List_First(&fragInfoList);
  602.     while (!List_IsAtEnd(&fragInfoList, (List_Links *) fragInfoPtr)) {
  603.     if (fragInfoPtr->timeToLive <= 0) {
  604.         /*
  605.          * FreeFragments will remove the element from the list
  606.          * but it will return the pointer to the next element
  607.          * so the while loop will work.
  608.          */
  609.  
  610.         if (ips_Debug) {
  611.         fprintf(stderr, "IP Frag timeout: src <%x, #%d>\n",
  612.             fragInfoPtr->source, fragInfoPtr->ident);
  613.         }
  614.  
  615.         fragInfoPtr = FreeFragments(fragInfoPtr);
  616.  
  617.         stats.ip.fragsTimedOut++;
  618.  
  619.     } else {
  620.         fragInfoPtr->timeToLive--;
  621.         fragInfoPtr = (DgramFragInfo *) 
  622.                 List_Next((List_Links *) fragInfoPtr);
  623.     }
  624.  
  625.     }
  626. }
  627.  
  628.  
  629. /*
  630.  *----------------------------------------------------------------------
  631.  *
  632.  * ReassemblePacket --
  633.  *
  634.  *    Given a packet that is a fragment of a datagram, try to reassemble
  635.  *    a complete datagram.
  636.  *
  637.  * Results:
  638.  *    TRUE        - the datagram was reassembled.
  639.  *    FALSE        - the fragment did not complete the datagram.
  640.  *
  641.  * Side effects:
  642.  *    The fragment will be added to the list of frgaments for this
  643.  *    datagram. If all fragments for the datagram have arrived, they
  644.  *    are consolidated into 1 buffer and the memory held by the fragments 
  645.  *    is freed.
  646.  *
  647.  *----------------------------------------------------------------------
  648.  */
  649.  
  650. static Boolean
  651. ReassemblePacket(fragInfoPtr, packetPtr)
  652.     register DgramFragInfo *fragInfoPtr;/* Info about existing fragments
  653.                      * for this datagram. */
  654.     IPS_Packet    *packetPtr;        /* Addr of ptr to Fragment (in) -- Addr
  655.                      * of ptr to completed datagram (out).*/
  656. {
  657.     register FragDataInfo    *dataPtr;    /* Ptr to element on the
  658.                          * fragment queue. */
  659.     register FragDataInfo    *newDataPtr;
  660.     register List_Links        *fragDataListPtr;
  661.     register Net_IPHeader    *ipHeaderPtr;
  662.     register int        fragOffset;
  663.     Address            ptr;
  664.     Boolean            first;
  665.     int                next;
  666.     int                lastByte;
  667.  
  668.     ipHeaderPtr = packetPtr->ipPtr;
  669.  
  670.     /*
  671.      * The fragOffset "is measured in units of 8 octets (64 bits)".
  672.      * It is necessary to use it as # of bytes, hence the multiplication
  673.      * by 8.  Note that we already byte swapped it before this routine was
  674.      * called.
  675.      */
  676.     fragOffset = ipHeaderPtr->fragOffset * 8;
  677.  
  678.     /*
  679.      * For the first fragment, allocate the fragment info data structure 
  680.      * and initialize it.
  681.      */
  682.     if (fragInfoPtr == (DgramFragInfo *) NULL) {
  683.     fragInfoPtr = (DgramFragInfo *) malloc(sizeof(DgramFragInfo));
  684.     fragInfoPtr->source    = ipHeaderPtr->source;
  685.     fragInfoPtr->dest    = ipHeaderPtr->dest;
  686.     fragInfoPtr->ident    = ipHeaderPtr->ident;
  687.     fragInfoPtr->protocol    = ipHeaderPtr->protocol;
  688.     fragInfoPtr->numFrags    = 0;
  689.     fragInfoPtr->timeToLive    = NET_IP_MAX_FRAG_TTL;
  690.     fragDataListPtr =  &(fragInfoPtr->dataList);
  691.     dataPtr = (FragDataInfo    *) fragDataListPtr;
  692.     List_Init(fragDataListPtr);
  693.  
  694.     List_InitElement((List_Links *) fragInfoPtr);
  695.     List_Insert((List_Links *) fragInfoPtr, LIST_ATFRONT(&fragInfoList));
  696.     } else {
  697.  
  698.     fragDataListPtr = &(fragInfoPtr->dataList);
  699.  
  700.     /*
  701.      * Insert a new fragment into the appropriate spot in the fragment
  702.      * list. Depending on the location, new fragments may or may not
  703.      * replace data in existing fragments.  (Note: this is contrary
  704.      * to RFC791 which says data in an arriving fragment should
  705.      * replace existing data. The algorithm to do that is a bit more
  706.      * complex than the one use below.)
  707.      *
  708.      * Step 1: search the list to find the first existing fragment
  709.      * that begins after the new fragment. When the loop is exited via
  710.      * the break, dataPtr will point to this existing fragment.
  711.      * If we don't take the break, dataPtr will point to the head of 
  712.      * the list and the new fragment belongs at the end of the list.
  713.      */
  714.  
  715.     LIST_FORALL(fragDataListPtr, (List_Links *) dataPtr) {
  716.         /*
  717.          * Find the first existing fragment that begins after 
  718.          * the new fragment.
  719.          */ 
  720.         if (fragOffset < dataPtr->fragOffset) {
  721.         break;
  722.         }
  723.     }
  724.  
  725.     /*
  726.      * Step 2: The new fragment is before dataPtr and after
  727.      * newDataPtr. newDataPtr could be the head of list which means
  728.      * the new fragment fits in front of all the other fragments.
  729.      * dataPtr could be the list head which means that the new
  730.      * fragment goes at the end of the list.
  731.      */
  732.  
  733.     newDataPtr = (FragDataInfo *) (List_Prev((List_Links *)dataPtr));
  734.  
  735.     if (!List_IsAtEnd(fragDataListPtr, (List_Links *)newDataPtr)) {
  736.  
  737.         int i = newDataPtr->fragOffset + newDataPtr->dataLen - 
  738.                 fragOffset;
  739.         /*
  740.          * "if (i > 0)" ==  if (fragOffset < last byte in preceeding 
  741.          * fragment) then the new fragment overlaps or is contained in 
  742.          * the preceeding fragment.
  743.          */
  744.  
  745.         if (i > 0) {
  746.         if (i >= ipHeaderPtr->totalLen) {
  747.             /*
  748.              * The new fragment is totally contained in the preceeding 
  749.              * fragment so drop the new fragment. 
  750.              *
  751.              * (If the new data were to replace the old, the preceeding 
  752.              * fragment would have to be split or the data from 
  753.              * the new fragment copied into the preceeding fragment.)
  754.              */
  755.  
  756.             if (ips_Debug) {
  757.             fprintf(stderr, "ReassemblePacket: Frag dropped\n");
  758.             }
  759.             stats.ip.fragsDropped++;
  760.             free(packetPtr->base);
  761.             return(FALSE);
  762.  
  763.         } else {
  764.             /*
  765.              * The end of the preceeding fragment needs to be trimmed 
  766.              * because the new fragment replaces that data.
  767.              * (4.3BSD keeps the old data and trims the front of
  768.              * the new fragment).
  769.              */
  770.              newDataPtr->dataLen -= i;
  771.         }
  772.         }
  773.     }
  774.  
  775.     /*
  776.      * Step 3:  see if the succeeding fragments need to be trimmed 
  777.      * because the end of the new fragment partially or completely 
  778.      * overlaps them.
  779.      */
  780.  
  781.     lastByte = fragOffset + ipHeaderPtr->totalLen;
  782.     while ((!List_IsAtEnd(fragDataListPtr, (List_Links *)dataPtr)) &&
  783.            (dataPtr->fragOffset < lastByte)) {
  784.  
  785.         if ((dataPtr->fragOffset + dataPtr->dataLen) < lastByte) {
  786.         /*
  787.          * The new fragment covers the old fragment so the
  788.          * old one can be freed.
  789.          */
  790.  
  791.         newDataPtr =  /* temp. holder */
  792.             (FragDataInfo *) (List_Next((List_Links *)dataPtr));
  793.         List_Remove((List_Links *)dataPtr);
  794.         free((char *) dataPtr->fragPacket.base);
  795.         free((char *) dataPtr);
  796.         dataPtr = newDataPtr;
  797.  
  798.         } else {
  799.         /*
  800.          * The new fragment covers some, but not all, of the old 
  801.          * fragment. Trim data from the start of the old one. 
  802.          * At this point we are also done trimming.
  803.          */
  804.         int trimAmt = lastByte - dataPtr->fragOffset;
  805.  
  806.         dataPtr->fragOffset    += trimAmt;
  807.         dataPtr->dataOffset    += trimAmt;
  808.         dataPtr->dataLen    -= trimAmt;
  809.         break;
  810.         }
  811.     }
  812.     }
  813.  
  814.     /*
  815.      * Insert the new fragment into the list of received fragments.
  816.      */
  817.  
  818.     fragInfoPtr->numFrags++;
  819.     newDataPtr = (FragDataInfo *) malloc(sizeof(FragDataInfo));
  820.     newDataPtr->fragOffset    = fragOffset;
  821.     newDataPtr->dataOffset    = ipHeaderPtr->headerLen * 4;
  822.     newDataPtr->dataLen        = ipHeaderPtr->totalLen -newDataPtr->dataOffset;
  823.     newDataPtr->fragPacket    = *packetPtr;
  824.  
  825.     List_InitElement((List_Links *) newDataPtr);
  826.     List_Insert((List_Links *)newDataPtr, LIST_BEFORE((List_Links *) dataPtr));
  827.  
  828.  
  829.     /*
  830.      * Now scan the data list for this datagram to see if all the 
  831.      * fragments have been received. "Next" is the next expected fragment
  832.      * offset.
  833.      */
  834.  
  835.     next = 0;
  836.     LIST_FORALL(fragDataListPtr, (List_Links *) dataPtr) {
  837.     if (dataPtr->fragOffset != next) {
  838.         /*
  839.          * Oops! Found a hole so the datagram is not yet complete.
  840.          */
  841.         if (ips_Debug) {
  842.         fprintf(stderr, "ReassemblePacket: Incomplete datagram\n");
  843.         }
  844.         return(FALSE);
  845.     } else {
  846.         next += dataPtr->dataLen;
  847.     }
  848.     }
  849.  
  850.     /*
  851.      * All the fragments are contiguous but we have to check if the
  852.      * last fragment has been received. This is done by checking 
  853.      * the NET_IP_MORE_FRAGS bit in the header of the queue's last fragment.
  854.      * If that bit is set, then the reassembly is not yet complete.
  855.      *
  856.      * (dataPtr should point to the head of the list so we need to look
  857.      * at the previous element.)
  858.      */
  859.  
  860.     newDataPtr = (FragDataInfo *) (List_Prev((List_Links *)dataPtr));
  861.     if (newDataPtr->fragPacket.ipPtr->flags & NET_IP_MORE_FRAGS) {
  862.     if (ips_Debug) {
  863.         fprintf(stderr, "ReassemblePacket: More frags\n");
  864.     }
  865.     return(FALSE);
  866.     }
  867.  
  868.     /*
  869.      * At this point, all the fragments have been received. A new buffer
  870.      * is allocated so all the fragments can be concatenated together into
  871.      * 1 datagram.  The datagram's IP header comes from the first fragment.
  872.      * After copying the fragment, the FragDatInfo element is removed from
  873.      * the list and freed, along with the fragment.
  874.      *
  875.      * (IPS_InitPacket will resuse packetPtr and allocate new memory. 
  876.      * We don't free(packetPtr->base) before calling IPS_InitPacket 
  877.      * because that buffer is already used in one of elements in the fragment 
  878.      * data list for this datagram.)
  879.      */
  880.  
  881.     if (ips_Debug) {
  882.     fprintf(stderr, "ReassemblePacket: All frags received\n");
  883.     }
  884.  
  885.     IPS_InitPacket(next, packetPtr);
  886.     ptr = packetPtr->dbase + sizeof(IPS_PacketNetHdr);
  887.     packetPtr->ipPtr = (Net_IPHeader *) ptr;
  888.  
  889.     first = TRUE;
  890.     dataPtr = (FragDataInfo *) List_First(fragDataListPtr);
  891.     while (!List_IsAtEnd(fragDataListPtr, (List_Links *) dataPtr)) {
  892.     if (first) {
  893.         int amtToCopy = dataPtr->fragPacket.ipPtr->totalLen;
  894.         first = FALSE;
  895.  
  896.         /*
  897.          * The header of the first fragment needs to be copied, too.
  898.          */
  899.         bcopy((Address) dataPtr->fragPacket.ipPtr, (Address) ptr,amtToCopy);
  900.  
  901.         /*
  902.          * Reset the size of the packet in the header.
  903.          */
  904.         packetPtr->ipLen = ((Net_IPHeader *) ptr)->totalLen = 
  905.                 next + (dataPtr->fragPacket.ipPtr->headerLen * 4);
  906.  
  907.         ptr += amtToCopy;
  908.     } else {
  909.         bcopy((Address) dataPtr->fragPacket.ipPtr+dataPtr->dataOffset, 
  910.             (Address) ptr, dataPtr->dataLen);
  911.         ptr += dataPtr->dataLen;
  912.     }
  913.  
  914.     newDataPtr = (FragDataInfo *) (List_Next((List_Links *)dataPtr));
  915.     List_Remove((List_Links *) dataPtr);
  916.     free((char *) dataPtr->fragPacket.base);
  917.     free((char *) dataPtr);
  918.     dataPtr = newDataPtr;
  919.     }
  920.     List_Remove((List_Links *) fragInfoPtr);
  921.     free((char *) fragInfoPtr);
  922.  
  923.     return(TRUE);
  924. }
  925.  
  926. /*
  927.  *----------------------------------------------------------------------
  928.  *
  929.  * FreeFragments --
  930.  *
  931.  *    Releases the fragments held while trying to reassemble a datagram.
  932.  *
  933.  * Results:
  934.  *    Address of the previous element in the fragInfoList.
  935.  *
  936.  * Side effects:
  937.  *    The saved packets are freed and the *fragInfoPtr is removed
  938.  *    from the fragment queue.
  939.  *
  940.  *----------------------------------------------------------------------
  941.  */
  942.  
  943. static DgramFragInfo *
  944. FreeFragments(fragInfoPtr)
  945.     register DgramFragInfo *fragInfoPtr; /* Info about existing fragments
  946.                       * for this datagram. */
  947. {
  948.     register List_Links    *dataPtr;
  949.     register List_Links    *nextPtr;
  950.     DgramFragInfo *savePtr; 
  951.  
  952.     /*
  953.      * We need to return the ptr to the next element so this routine
  954.      * can be called inside of a list-examining loop and still be able 
  955.      * to remove the element from the list.
  956.      */
  957.     savePtr = (DgramFragInfo *) List_Next((List_Links *) fragInfoPtr);
  958.     List_Remove((List_Links *) fragInfoPtr);
  959.  
  960.     LIST_FORALL(&(fragInfoPtr->dataList), dataPtr) {
  961.     nextPtr = List_Next(dataPtr);
  962.     List_Remove(dataPtr);
  963.     free((char *) ((FragDataInfo *)dataPtr)->fragPacket.base);
  964.     free((char *) dataPtr);
  965.     dataPtr = nextPtr;
  966.     }
  967.     free((char *) fragInfoPtr);
  968.     return(savePtr);
  969. }
  970.  
  971.  
  972. /*
  973.  *----------------------------------------------------------------------
  974.  *
  975.  * ForwardPacket --
  976.  *
  977.  *    Given an packet that's not for us, this routine determines which 
  978.  *    host the packet should be forwarded to and tries to send it to
  979.  *    that host (possibly via gateways).
  980.  *
  981.  *    For now, we don't do forwarding -- the packet is just dropped.
  982.  *    This will need to change when Sprite machines want to act
  983.  *    as gateways/routers.
  984.  *
  985.  *
  986.  * Results:
  987.  *    None.
  988.  *
  989.  * Side effects:
  990.  *    None.
  991.  *
  992.  *----------------------------------------------------------------------
  993.  */
  994.  
  995. /*ARGSUSED*/
  996. static void
  997. ForwardPacket(packetPtr)
  998.     IPS_Packet    *packetPtr;    /* Packet layout descriptor. */
  999. {
  1000.     stats.ip.cannotForward++;
  1001. }
  1002.  
  1003.  
  1004. /*
  1005.  *----------------------------------------------------------------------
  1006.  *
  1007.  * ProcessOptions --
  1008.  *
  1009.  *    This routine decodes the option(s) that follow the IP header
  1010.  *    and processes it/them.
  1011.  *
  1012.  * Results:
  1013.  *    None.
  1014.  *
  1015.  * Side effects:
  1016.  *    An ICMP packet is sent to the packet sender if if an option is 
  1017.  *    malformed. The Record Route and Timestamp options modify the
  1018.  *    the packet.
  1019.  *
  1020.  *----------------------------------------------------------------------
  1021.  */
  1022.  
  1023. static ReturnStatus
  1024. ProcessOptions(hdrLen, ipHeaderPtr)
  1025.     int hdrLen;                /* Header length in bytes. */
  1026.     register Net_IPHeader *ipHeaderPtr;    /* IP header with trailing options. */
  1027. {
  1028.     register Address optionPtr;        /* Ptr to the current option in the
  1029.                      * IP header that's being processed. */
  1030.     int        optionType;
  1031.     int        optionLen;
  1032.     int        totalOptionSize;
  1033.     int        ptr;
  1034.     int        icmpCode;
  1035.     int        icmpType;
  1036.  
  1037.  
  1038.     /*
  1039.      * Go through the option area of the packet and process each option.
  1040.      * The options begin just after the standard header info.
  1041.      */
  1042.     
  1043.     optionPtr = ((Address) ipHeaderPtr) + sizeof(Net_IPHeader) + 1;
  1044.  
  1045.     for (totalOptionSize = hdrLen - sizeof(Net_IPHeader); 
  1046.      totalOptionSize > 0; 
  1047.      totalOptionSize -= optionLen, optionPtr += optionLen) {
  1048.  
  1049.     optionType = optionPtr[NET_IP_OPT_TYPE_OFFSET];
  1050.  
  1051.     /*
  1052.      * Decode the option. END_OF_LIST and NOP options are only 1
  1053.      * octet long. The rest of the options have a length field that 
  1054.      * must be checked.
  1055.      */
  1056.  
  1057.     if (optionType == NET_IP_OPT_END_OF_LIST) {
  1058.         break;
  1059.     } else if (optionType == NET_IP_OPT_NOP) {
  1060.         optionLen = 1;
  1061.     } else {
  1062.         optionLen = optionPtr[NET_IP_OPT_LEN_OFFSET];
  1063.         if (optionLen <= 0 || optionLen > totalOptionSize) {
  1064.         icmpType = NET_ICMP_PARAM_PROB;
  1065.         icmpCode = &optionPtr[NET_IP_OPT_LEN_OFFSET] - 
  1066.                 (Address) ipHeaderPtr;
  1067.         goto bad;
  1068.         }
  1069.  
  1070.         switch (optionType) {
  1071.  
  1072.         /*
  1073.          * Loose and strict source routing and record options:
  1074.          *
  1075.          * If the packet is not directed towards one of our
  1076.          * Internet addresses then send an ICMP error packet if
  1077.          * strict routing is wanted or do nothing if loosely
  1078.          * routed.  Also, record our address in the option area
  1079.          * and make the next address in the routing list as the
  1080.          * destination.  If strictly-routed, make sure the next
  1081.          * address is on a directly-accessible network.
  1082.          */
  1083.  
  1084.         case NET_IP_OPT_LOOSE_ROUTE:
  1085.         case NET_IP_OPT_STRICT_ROUTE:
  1086.  
  1087.             ptr = optionPtr[NET_IP_OPT_PTR_OFFSET];
  1088.             if (ptr < NET_IP_OPT_MIN_PTR) {
  1089.             icmpType = NET_ICMP_PARAM_PROB;
  1090.             icmpCode = &optionPtr[NET_IP_OPT_PTR_OFFSET]  -
  1091.                     (Address) ipHeaderPtr;
  1092.             goto bad;
  1093.             }
  1094.  
  1095.             if (!Rte_AddrIsForUs(ipHeaderPtr->dest)) {
  1096.             if (optionType == NET_IP_OPT_STRICT_ROUTE) {
  1097.                 icmpType = NET_ICMP_UNREACHABLE;
  1098.                 icmpCode = NET_ICMP_UNREACH_SRC_ROUTE;
  1099.                 goto bad;
  1100.             }
  1101.             /*
  1102.              * Loose routing, and not at next destination
  1103.              * yet; nothing to do except forward.
  1104.              */
  1105.             break;
  1106.             }
  1107.  
  1108.             ptr--;            /* 0 origin */
  1109.             if (ptr > optionLen - sizeof(Net_InetAddress)) {
  1110.             /*
  1111.              * End of source route.  Should be for us.
  1112.              */
  1113.             SaveRoute(optionPtr, ipHeaderPtr->source);
  1114.  
  1115.             } else {
  1116.             Net_InetAddress addr;
  1117.  
  1118.             /*
  1119.              * We are an intermediate host in the routing list.
  1120.              * Change the packet's destination to the next host in 
  1121.              * the list and record our address there.
  1122.              */
  1123.             addr = *((Net_InetAddress *)(optionPtr + ptr));
  1124.                 
  1125.             if ((optionType == NET_IP_OPT_STRICT_ROUTE) && 
  1126.                 !CanForward(addr)) {
  1127.                 icmpType = NET_ICMP_UNREACHABLE;
  1128.                 icmpCode = NET_ICMP_UNREACH_SRC_ROUTE;
  1129.                 goto bad;
  1130.             }
  1131.             *((Net_InetAddress *)(optionPtr + ptr)) =
  1132.                     (ipHeaderPtr->dest);
  1133.             optionPtr[NET_IP_OPT_PTR_OFFSET] += 
  1134.                     sizeof(Net_InetAddress);
  1135.             ipHeaderPtr->dest = addr;
  1136.             }
  1137.             break;
  1138.  
  1139.  
  1140.         /*
  1141.          * Record Route option: 
  1142.          *
  1143.          *  Add our address in the area reserved for routes.
  1144.          */
  1145.  
  1146.         case NET_IP_OPT_REC_ROUTE: 
  1147.             {
  1148.             ptr = optionPtr[NET_IP_OPT_PTR_OFFSET];
  1149.             if (ptr < NET_IP_OPT_MIN_PTR) {
  1150.                 icmpType = NET_ICMP_PARAM_PROB;
  1151.                 icmpCode= &optionPtr[NET_IP_OPT_PTR_OFFSET]  -
  1152.                     (Address) ipHeaderPtr;
  1153.                 goto bad;
  1154.             }
  1155.  
  1156.             /*
  1157.              * If no space remains, do nothing.
  1158.              */
  1159.             ptr--;            /* 0 origin */
  1160.             if (ptr <= (optionLen - sizeof(Net_InetAddress))) {
  1161.                 /*
  1162.                  * See if we can forward this packet before our
  1163.                  * address is recorded in the routing list.
  1164.                  */
  1165.  
  1166.                 if (!CanForward(ipHeaderPtr->dest)) {
  1167.                     icmpType = NET_ICMP_UNREACHABLE;
  1168.                     icmpCode = NET_ICMP_UNREACH_SRC_ROUTE;
  1169.                     goto bad;
  1170.                 }
  1171.                 *((Net_InetAddress *)(optionPtr + ptr)) =
  1172.                  (Rte_GetOfficialAddr(FALSE));
  1173.  
  1174.                 optionPtr[NET_IP_OPT_PTR_OFFSET] += 
  1175.                     sizeof(Net_InetAddress);
  1176.             }
  1177.             }
  1178.             break;
  1179.  
  1180.         /*
  1181.          * Timestamp option: 
  1182.          *
  1183.          * Add a timestamp (and optionally our address) in the area 
  1184.          * reserved for it.
  1185.          */
  1186.  
  1187.         case NET_IP_OPT_TIMESTAMP: 
  1188.             {
  1189.             Net_InetTime    time;
  1190.             Net_InetAddress *addrPtr;
  1191.             Net_IPTimestampHdr *tsPtr =
  1192.                     (Net_IPTimestampHdr *)optionPtr;
  1193.  
  1194.             if (tsPtr->len < 5) {
  1195.                 icmpType = NET_ICMP_PARAM_PROB;
  1196.                 icmpCode = optionPtr - (Address) ipHeaderPtr;
  1197.                 goto bad;
  1198.             }
  1199.  
  1200.             if (tsPtr->pointer > (tsPtr->len - sizeof(*tsPtr))) {
  1201.                 tsPtr->overflow++;
  1202.                 if (tsPtr->overflow == 0) {
  1203.                 icmpType = NET_ICMP_PARAM_PROB;
  1204.                 icmpCode = optionPtr - (Address) ipHeaderPtr;
  1205.                 goto bad;
  1206.                 }
  1207.                 break;
  1208.             }
  1209.  
  1210.             addrPtr = (Net_InetAddress *)
  1211.                     (optionPtr + tsPtr->pointer -1);
  1212.  
  1213.             switch (tsPtr->flags) {
  1214.  
  1215.                 case NET_IP_OPT_TS_ONLY:
  1216.                 break;
  1217.  
  1218.                 /*
  1219.                  * Add our address to the packet if there's room.
  1220.                  */
  1221.                 case NET_IP_OPT_TS_AND_ADDR:
  1222.                 if ((tsPtr->pointer + sizeof(Net_InetTime) +
  1223.                     sizeof(Net_InetAddress)) > tsPtr->len) {
  1224.                     icmpType = NET_ICMP_PARAM_PROB;
  1225.                     icmpCode = optionPtr -
  1226.                             (Address) ipHeaderPtr;
  1227.                     goto bad;
  1228.                 }
  1229.                 *addrPtr = (Rte_GetOfficialAddr(FALSE));
  1230.                 tsPtr->pointer += sizeof(*addrPtr);
  1231.                 break;
  1232.  
  1233.                 /*
  1234.                  * Add our address to the packet only if our
  1235.                  * address in the list of prespecified addresses.
  1236.                  */
  1237.                 case NET_IP_OPT_TS_ADDR_SPEC:
  1238.                 if ((tsPtr->pointer + sizeof(Net_InetTime) +
  1239.                     sizeof(Net_InetAddress)) > tsPtr->len) {
  1240.  
  1241.                     icmpType = NET_ICMP_PARAM_PROB;
  1242.                     icmpCode = optionPtr - 
  1243.                             (Address) ipHeaderPtr;
  1244.                     goto bad;
  1245.                 }
  1246.                 if (!Rte_AddrIsForUs((*addrPtr))) {
  1247.                     continue;
  1248.                 }
  1249.                 tsPtr->pointer += sizeof(*addrPtr);
  1250.                 break;
  1251.  
  1252.                 default:
  1253.                     /*
  1254.                      * Unknown timestamp flag.
  1255.                      */
  1256.                     icmpType = NET_ICMP_PARAM_PROB;
  1257.                     icmpCode = optionPtr -(Address) ipHeaderPtr;
  1258.                     goto bad;
  1259.             }
  1260.             time = Net_HostToNetInt(IPS_GetTimestamp());
  1261.             bcopy( (Address)&time, 
  1262.                       (Address) (optionPtr + tsPtr->pointer -1),
  1263.                   sizeof(time));
  1264.             tsPtr->pointer += sizeof(time);
  1265.             }
  1266.             break;
  1267.  
  1268.         /*
  1269.          * The following options aren't handled yet.
  1270.          */
  1271.         case NET_IP_OPT_STREAM_ID:
  1272.         case NET_IP_OPT_SECURITY:
  1273.         default:
  1274.             break;
  1275.         }
  1276.     }
  1277.     }
  1278.     return(SUCCESS);
  1279.  
  1280.     /*
  1281.      * We are sent here if there was an error with an option's format.
  1282.      * Send an ICMP error packet to the source.
  1283.      */
  1284. bad:
  1285.     ICMP_SendErrorMsg(ipHeaderPtr, icmpType, icmpCode);
  1286.     return (FAILURE);
  1287. }
  1288.  
  1289.  
  1290. /*
  1291.  *----------------------------------------------------------------------
  1292.  *
  1293.  * CanForward --
  1294.  *
  1295.  *     Given an address of the next destination (final or next hop),
  1296.  *     indicate whether we can foraward the packet.
  1297.  *
  1298.  * Results:
  1299.  *    TRUE    - we are able to forward the packet.
  1300.  *    FALSE    - we are not able to forward the packet.
  1301.  *
  1302.  * Side effects:
  1303.  *    None.
  1304.  *
  1305.  *----------------------------------------------------------------------
  1306.  */
  1307.  
  1308. /*ARGSUSED*/
  1309. static Boolean
  1310. CanForward(dest)
  1311.      Net_InetAddress dest;
  1312. {
  1313.     /*
  1314.      * For now, say we can't forward anything.
  1315.      */
  1316.     return(FALSE);
  1317. }
  1318.  
  1319.  
  1320. /*
  1321.  * We need to save the IP options in case a higher-level protocol wants 
  1322.  * to respond to an incoming packet over the same route if the packet got
  1323.  * here using IP source routing.  This allows connection establishment and
  1324.  * maintenance when the remote end is on a network that is not known to us.
  1325.  *
  1326.  * MAX_SAVE_ADDRS is the max. # of IP addresses that can be stored in
  1327.  * an IP record route option. Subtract 3 for the record route info (type,
  1328.  * length and pointer).
  1329.  */
  1330.  
  1331. #define MAX_SAVE_ADDRS  ((NET_IP_OPT_MAX_LEN - 3)/sizeof(Net_InetAddress))
  1332. static struct {
  1333.     int numHops;                /* # of addresses in addr. */
  1334.     struct {
  1335.     struct {
  1336.         char    nop;        /* One NOP to align when 
  1337.                      * returning the route. */
  1338.         char    type;        /* Option type */
  1339.         char    len;        /* Totol length of info + addr. */
  1340.         char    ptr;        /* Offset where routes start. */
  1341.     } info;
  1342.     Net_InetAddress addr[MAX_SAVE_ADDRS];    /* List of routes. */
  1343.     } route;
  1344.     Net_InetAddress     dest;        /* In host byte order. */
  1345. } savedSrcRoute = { 0, {{NET_IP_OPT_NOP,}, }, };
  1346.  
  1347. /*
  1348.  *----------------------------------------------------------------------
  1349.  *
  1350.  * SaveRoute --
  1351.  *
  1352.  *    Save incoming source route for use in replies,
  1353.  *    to be picked up later by IP_SrcRoute if the receiver is interested.
  1354.  *    The options are kept in network byte order.
  1355.  *
  1356.  *
  1357.  * Results:
  1358.  *    None.
  1359.  *
  1360.  * Side effects:
  1361.  *    The route is stored in a static buffer.
  1362.  *
  1363.  *----------------------------------------------------------------------
  1364.  */
  1365.  
  1366. static void
  1367. SaveRoute(optionPtr, dest)
  1368.     Address    optionPtr;    /* Ptr to IP options buffer containing source
  1369.                  * routing option. */
  1370.     Net_InetAddress dest;    /* Next destination address to put in the
  1371.                  * saved source route. */
  1372. {
  1373.     int optLen;
  1374.  
  1375.     optLen = optionPtr[NET_IP_OPT_LEN_OFFSET];
  1376.     if (optLen > sizeof(savedSrcRoute.route) - 1) {
  1377.     (void) fprintf(stderr, "Warning: SaveRoute (IP): optLen (%d) bad\n", optLen);
  1378.     return;
  1379.     }
  1380.     bcopy(optionPtr, (Address)&savedSrcRoute.route.info.type, optLen);
  1381.     savedSrcRoute.numHops = (optLen - 3) / sizeof(Net_InetAddress);
  1382.     savedSrcRoute.dest = dest;
  1383. }
  1384.  
  1385.  
  1386. /*
  1387.  *----------------------------------------------------------------------
  1388.  *
  1389.  * IP_GetSrcRoute --
  1390.  *
  1391.  *    Get the incoming source route that was saved in savedSrcRoute
  1392.  *    for use in replies. The first hop is returned in *destPtr.
  1393.  *
  1394.  * Results:
  1395.  *    The address of a buffer containing the saved source route from the
  1396.  *    most recent IP packet.
  1397.  *
  1398.  * Side effects:
  1399.  *    None.
  1400.  *
  1401.  *----------------------------------------------------------------------
  1402.  */
  1403.  
  1404. Address 
  1405. IP_GetSrcRoute(lenPtr, destPtr)
  1406.     int    *lenPtr;        /* Out: Size of source-route buffer. */
  1407.     Net_InetAddress *destPtr;    /* Out: address of the first destination. */
  1408. {
  1409.     register Net_InetAddress *oldPtr, *newPtr;
  1410.     register Address routePtr;
  1411.     int    len;
  1412.  
  1413.     if (savedSrcRoute.numHops == 0) {
  1414.     *lenPtr = 0;
  1415.     return((Address) NULL);
  1416.     }
  1417.  
  1418.     len = ((1 + savedSrcRoute.numHops) * sizeof(Net_InetAddress)) +
  1419.         sizeof(savedSrcRoute.route.info);
  1420.     *lenPtr = len;
  1421.  
  1422.     /*
  1423.      * Allocate a buffer to hold the source route.
  1424.      */
  1425.     routePtr = malloc((unsigned int) len);
  1426.  
  1427.     /*
  1428.      * First the save first hop for return route.
  1429.      */
  1430.     *destPtr = savedSrcRoute.dest;
  1431.  
  1432.     /*
  1433.      * Copy the route info.
  1434.      */
  1435.     bcopy( (Address) &savedSrcRoute.route.info, routePtr,
  1436.         sizeof(savedSrcRoute.route.info));
  1437.     newPtr = (Net_InetAddress *) (routePtr + sizeof(savedSrcRoute.route.info));
  1438.                 
  1439.     /*
  1440.      * Record return path as an IP source route, reversing the path.
  1441.      */
  1442.     oldPtr = &savedSrcRoute.route.addr[savedSrcRoute.numHops -1];
  1443.     while (oldPtr >= savedSrcRoute.route.addr) {
  1444.     *newPtr++ = *oldPtr--;
  1445.     }
  1446.     return(routePtr);
  1447. }
  1448.  
  1449.  
  1450. /*
  1451.  *----------------------------------------------------------------------
  1452.  *
  1453.  * IP_Output --
  1454.  *
  1455.  *    Causes an IP packet to sent to the network. The packet may be
  1456.  *    fragmented if it's too large for the chosen network.
  1457.  *
  1458.  * Results:
  1459.  *    SUCCESS            - the datagram was sent out.
  1460.  *    FS_BUFFER_TOO_BIG    - the datagram was too large and had to be
  1461.  *                  fragmented but the DONT_FRAG bit was set
  1462.  *                  in the header.
  1463.  *    NET_UNREACHABLE        - couldn't find a network to send the datagram
  1464.  *                  to.
  1465.  *
  1466.  * Side effects:
  1467.  *    Packet(s) may be output.
  1468.  *
  1469.  *----------------------------------------------------------------------
  1470.  */
  1471.  
  1472. ReturnStatus
  1473. IP_Output(packetPtr, canTrash)
  1474.     register IPS_Packet *packetPtr;    /* Packet layout descriptor. IP-related
  1475.                      * fields are filled in. If the packet
  1476.                      * is fragmented, the data and hdrLen
  1477.                      * fields are modified. */
  1478.     Boolean canTrash;            /* TRUE if the packet will be discarded
  1479.                      * after output.  If so, then we can
  1480.                      * optimize fragmentation by writing
  1481.                      * packet headers over some data. */
  1482. {
  1483.     ReturnStatus    status;
  1484.     int            headerLenInBytes;
  1485.     int            maxOutSize;
  1486.     Rte_NetID        netID;
  1487.     register Net_IPHeader *headerPtr = packetPtr->ipPtr;
  1488.  
  1489.  
  1490.     headerLenInBytes = headerPtr->headerLen * 4;
  1491.  
  1492.     if (headerLenInBytes > NET_IP_MAX_HDR_SIZE) {
  1493.     return(FAILURE);
  1494.     }
  1495.  
  1496.  
  1497.     /*
  1498.      * Determine which network interface must be used to output this
  1499.      * datagram.
  1500.      */
  1501.  
  1502.     if (!Rte_FindOutputNet(headerPtr->dest,  &netID, &maxOutSize)) {
  1503.     return(NET_UNREACHABLE_NET);
  1504.     }
  1505.  
  1506. #ifdef notdef
  1507.     headerPtr->source = Net_HostToNetInt(headerPtr->source);
  1508.     headerPtr->dest   = Net_HostToNetInt(headerPtr->dest);
  1509. #endif
  1510.  
  1511.     /*
  1512.      * See if the datagram is small enough to be sent in 1 piece.
  1513.      */
  1514.  
  1515.     if (headerPtr->totalLen <= maxOutSize) {
  1516.     int    totalLen;
  1517.  
  1518.     stats.ip.wholeSent++;
  1519.     totalLen = headerPtr->totalLen;
  1520.     headerPtr->totalLen = Net_HostToNetShort(totalLen);
  1521.     headerPtr->fragOffset = 0;
  1522.     headerPtr->flags = 0;
  1523.     headerPtr->checksum = 0;
  1524.     headerPtr->checksum = Net_InetChecksum(headerLenInBytes, 
  1525.                     (Address) headerPtr);
  1526.     packetPtr->ipLen = headerLenInBytes;
  1527.     status = Rte_OutputPacket(netID, packetPtr);
  1528.  
  1529.     } else if (headerPtr->flags & NET_IP_DONT_FRAG) {
  1530.     /*
  1531.      * The datagram is too big but the higher-level protocol doesn't want
  1532.      * it to be fragmented. Better tell the sender that it's too big.
  1533.      */
  1534.  
  1535.     stats.ip.dontFragment++;
  1536.  
  1537.     status = FS_BUFFER_TOO_BIG;
  1538.     } else {
  1539.  
  1540.     register Address fragPtr;
  1541.     register Address dataPtr;
  1542.     int        totalDataLen;
  1543.     int        fragDataLen;
  1544.     int        fragHdrLen;
  1545.     int        offset;
  1546.     IPS_Packet     packet;
  1547.     char        ipHeader[NET_IP_MAX_HDR_SIZE];
  1548.  
  1549.     stats.ip.fragOnSend++;
  1550.  
  1551.     /*
  1552.      * The datagram is too big to send as 1 packet on the network
  1553.      * (identified by netID) but we can fragment the datagram into 
  1554.      * several packets and send them out individually. 
  1555.      *
  1556.      * Each fragment contains an IP header based on the original
  1557.      * header plus some portion of the data.  Options in the IP header
  1558.      * require special handling. All options in the original header
  1559.      * need to go in the first fragment's header.  In succeeding
  1560.      * fragments, only some of the options are included in the header.
  1561.      *
  1562.      * TotalDataLen is the number of bytes of data in the datagram and
  1563.      * fragDataLen is the amount of data that can fit into a fragment.
  1564.      * Actually fragDataLen must be a multiple of 8 (c.f. p. 25 in RFC791);
  1565.      * this done by masking off the low-order 3 bits.
  1566.      */
  1567.  
  1568.     totalDataLen = headerPtr->totalLen - headerLenInBytes;
  1569.     fragDataLen = (maxOutSize - headerLenInBytes) & ~7;
  1570.  
  1571.     /*
  1572.      * Output the first fragment. We use the orginal datagram by modifying 
  1573.      * the header and telling the output routine how many bytes to output 
  1574.      * so we can avoid copying.
  1575.      */
  1576.  
  1577.     headerPtr->flags = NET_IP_MORE_FRAGS;
  1578.     headerPtr->fragOffset = 0;
  1579.     SWAP_FRAG_OFFSET_HOST_TO_NET(headerPtr);
  1580.  
  1581.     headerPtr->totalLen = Net_HostToNetShort(fragDataLen+headerLenInBytes);
  1582.     headerPtr->checksum = 0;
  1583.     headerPtr->checksum = Net_InetChecksum(headerLenInBytes, 
  1584.                     (Address) headerPtr);
  1585.     packetPtr->dataLen = fragDataLen;
  1586.     packetPtr->ipLen = headerLenInBytes;
  1587.  
  1588.     /*
  1589.      * Reset the packet's higher-level protocol header length to 0.
  1590.      * That header is now considered part of the data.
  1591.      */
  1592.     packetPtr->hdrLen = 0;
  1593.     status = Rte_OutputPacket(netID, packetPtr);
  1594.     stats.ip.fragsSent++;
  1595.     if (status != SUCCESS) {
  1596.         return(status);
  1597.     }
  1598.  
  1599.     /*
  1600.      * The first fragDataLen bytes have been sent. DataPtr is set to
  1601.      * point to the next byte in the original datagram to be sent.
  1602.      */
  1603.     dataPtr = (Address) (((Address) headerPtr) + headerLenInBytes + 
  1604.                 fragDataLen);
  1605.  
  1606.     /*
  1607.      * Now allocate a buffer that will be used to send the rest of the
  1608.      * fragments.  We must over-allocate the space because we don't
  1609.      * know how much room the header options need until we copy them
  1610.      * (only some options are copied). The rest of the buffer will 
  1611.      * hold part of the data from the original packet.  We reuse this 
  1612.      * buffer for all remaining fragments, adjusting the header if 
  1613.      * necessary.
  1614.      *
  1615.      * CAN_TRASH:  If we can trash the packet then we do so by writing
  1616.      * the fragment headers over existing data.  This eliminates the
  1617.      * need to allocate a buffer and copy data into it.  The variable
  1618.      * dataPtr always references the next data byte to be output.
  1619.      * packet.base is set to be in front of this enough to fit the header.
  1620.      */
  1621.  
  1622. #define fragHdrPtr ((Net_IPHeader *)fragPtr)
  1623.  
  1624.     packet.totalLen = fragDataLen + headerLenInBytes + 
  1625.                    sizeof(IPS_PacketNetHdr);
  1626.     packet.hdrLen = 0;
  1627.     if (!canTrash) {
  1628.         /*
  1629.          * Allocate a packet buffer and copy the header into it.  Note that
  1630.          * we add two the allocated pointer so that we four byte align
  1631.          * everything but the 14 byte ethernet header.
  1632.          */
  1633.         packet.base = malloc((unsigned int) packet.totalLen + 2);
  1634.         packet.dbase = packet.base + 2;
  1635.         fragPtr = packet.dbase + sizeof(IPS_PacketNetHdr);
  1636.         fragHdrLen = CopyHeader(headerLenInBytes, headerPtr, 
  1637.                     (Net_IPHeader *)fragPtr);
  1638.         packet.ipPtr = fragHdrPtr;
  1639.         fragHdrPtr->headerLen = fragHdrLen / 4;
  1640.     } else {
  1641.         /*
  1642.          * Just save the fragment header and get its length.
  1643.          */
  1644.         fragHdrLen = CopyHeader(headerLenInBytes, headerPtr, ipHeader);
  1645.     }
  1646.     packet.ipLen = fragHdrLen;
  1647.  
  1648.     for (offset = fragDataLen; 
  1649.          offset < totalDataLen; 
  1650.          offset += fragDataLen, dataPtr += fragDataLen) {
  1651.  
  1652.         if (canTrash) {
  1653.         /*
  1654.          * Copy the fragment header in front of the next data to go out.
  1655.          */
  1656.         fragPtr = dataPtr - fragHdrLen;
  1657.         bcopy((char *)ipHeader, fragPtr, fragHdrLen);
  1658.         packet.base = packet.dbase = fragPtr - sizeof(IPS_PacketNetHdr);
  1659.         packet.ipPtr = fragHdrPtr;
  1660.         fragHdrPtr->headerLen = fragHdrLen / 4;
  1661.         }
  1662.         if (offset + fragDataLen >= totalDataLen) {
  1663.         /*
  1664.          * Last fragment reached. Must turn off MORE_FRAGS so the
  1665.          * receiver won't expect more data.
  1666.          */
  1667.         fragDataLen =  totalDataLen - offset;
  1668.         fragHdrPtr->flags = 0;
  1669.         } else {
  1670.         fragHdrPtr->flags = NET_IP_MORE_FRAGS;
  1671.         }
  1672.         fragHdrPtr->fragOffset = offset >> 3;
  1673.         SWAP_FRAG_OFFSET_HOST_TO_NET(fragHdrPtr);
  1674.  
  1675.         fragHdrPtr->totalLen = Net_HostToNetShort(fragDataLen + fragHdrLen);
  1676.  
  1677.  
  1678.         if (!canTrash) {
  1679.         /*
  1680.          * Copy the data into the extra packet.
  1681.          */
  1682.         bcopy( (Address) dataPtr, 
  1683.             (Address) fragPtr+fragHdrLen, fragDataLen);
  1684.         }
  1685.  
  1686.         fragHdrPtr->checksum = 0;
  1687.         fragHdrPtr->checksum = Net_InetChecksum(fragHdrLen, 
  1688.                         (Address) fragHdrPtr);
  1689.         packet.data = fragPtr + packet.ipLen;
  1690.         packet.dataLen = fragDataLen;
  1691.         status = Rte_OutputPacket(netID, &packet);
  1692.         stats.ip.fragsSent++;
  1693.         if (status != SUCCESS) {
  1694.         break;
  1695.         }
  1696.     }
  1697.     if (!canTrash) {
  1698.         free(packet.base);
  1699.     }
  1700.     }
  1701.     return (status);
  1702. }
  1703.  
  1704.  
  1705. /*
  1706.  *----------------------------------------------------------------------
  1707.  *
  1708.  * IP_QueueOutput --
  1709.  *
  1710.  *    Queues up a packet to be sent at a later time by IP_DelayedOutput.
  1711.  *
  1712.  * Results:
  1713.  *    None.
  1714.  *
  1715.  * Side effects:
  1716.  *    A queued packet may be sent.
  1717.  *    The packet is freed once IP_Output is called.
  1718.  *
  1719.  *----------------------------------------------------------------------
  1720.  */
  1721.  
  1722. static IPS_Packet queuedPacket;
  1723. static Boolean     isPacketQueued = FALSE;
  1724.  
  1725. void
  1726. IP_QueueOutput(packetPtr)
  1727.     IPS_Packet *packetPtr;    /* Packet layout descriptor. */
  1728. {
  1729.     if (isPacketQueued) {
  1730.     isPacketQueued = FALSE;
  1731.     (void) IP_Output(&queuedPacket, TRUE);
  1732.     free(queuedPacket.base);
  1733.  
  1734.     (void) IP_Output(packetPtr, TRUE);
  1735.     free(packetPtr->base);
  1736.     } else {
  1737.     isPacketQueued = TRUE;
  1738.     queuedPacket = *packetPtr;
  1739.     }
  1740. }
  1741.  
  1742.  
  1743. /*
  1744.  *----------------------------------------------------------------------
  1745.  *
  1746.  * IP_DelayedOutput --
  1747.  *
  1748.  *    Causes a queued IP packet to be output.
  1749.  *
  1750.  * Results:
  1751.  *    None.
  1752.  *
  1753.  * Side effects:
  1754.  *    The packet is freed once IP_Output is called.
  1755.  *
  1756.  *----------------------------------------------------------------------
  1757.  */
  1758.  
  1759. void
  1760. IP_DelayedOutput()
  1761. {
  1762.     if (isPacketQueued) {
  1763.     isPacketQueued = FALSE;
  1764.     (void) IP_Output(&queuedPacket, TRUE);
  1765.     free(queuedPacket.base);
  1766.     }
  1767. }
  1768.  
  1769.  
  1770. /*
  1771.  *----------------------------------------------------------------------
  1772.  *
  1773.  * CopyHeader --
  1774.  *
  1775.  *    Copies the IP header from a unfragmented datagram to a fragmented
  1776.  *    datagram. The basic IP header is copied from the source datagram 
  1777.  *    along with some of the options to the destination datagram.
  1778.  *    According to RFC791, only certain options are copied to fragment
  1779.  *    headers.
  1780.  *
  1781.  * Results:
  1782.  *    The length in bytes of the copied header.
  1783.  *
  1784.  * Side effects:
  1785.  *    None.
  1786.  *
  1787.  *----------------------------------------------------------------------
  1788.  */
  1789.  
  1790. static int
  1791. CopyHeader(srcHdrLen, srcHdrPtr, destHdrPtr)
  1792.     int        srcHdrLen;        /* # of bytes in the src header. */
  1793.     Net_IPHeader *srcHdrPtr;        /* Ptr to original datagram header. */
  1794.     Net_IPHeader *destHdrPtr;        /* Ptr to fragment datagram header. */
  1795. {
  1796.     register unsigned char *srcPtr;    /* Ptr to the source's options area. */
  1797.     register unsigned char *destPtr;    /* Ptr to the dest's options area. */
  1798.     int        optionAreaLen;        /* # of bytes of options that have been
  1799.                      * copied from the source to dest. */
  1800.     int        option;            /* Current option. */
  1801.     int        optionLen;        /* Lenght in bytes of current option.*/
  1802.  
  1803.     /*
  1804.      * First copy the basic IP header that is required for every IP datagram.
  1805.      */
  1806.     *destHdrPtr = *srcHdrPtr;
  1807.  
  1808.     /*
  1809.      * Now selectively copy options from the source packet to the dest
  1810.      * packet header. The dest packet is a fragment and only some of the
  1811.      * options need to be copied to it.
  1812.      */
  1813.     srcPtr  = (unsigned char *)((Address)srcHdrPtr  + sizeof(Net_IPHeader));
  1814.     destPtr = (unsigned char *)((Address)destHdrPtr + sizeof(Net_IPHeader));
  1815.  
  1816.     optionAreaLen = srcHdrLen - sizeof(Net_IPHeader);
  1817.  
  1818.     for ( ; optionAreaLen > 0; optionAreaLen -= optionLen, srcPtr += optionLen){
  1819.         option = srcPtr[0];
  1820.         if (option == NET_IP_OPT_END_OF_LIST) {
  1821.         break;
  1822.         }
  1823.         if (option == NET_IP_OPT_NOP) {
  1824.         optionLen = 1;
  1825.         } else {
  1826.         optionLen = srcPtr[NET_IP_OPT_LEN_OFFSET];
  1827.         }
  1828.  
  1829.         if (optionLen > optionAreaLen) {
  1830.         (void) fprintf(stderr, 
  1831.             "Warning: (IP) CopyOption: bad option length %d\n", 
  1832.             optionLen);
  1833.         optionLen = optionAreaLen;
  1834.         }
  1835.  
  1836.         /*
  1837.          * Copy the option if it's supposed to be copied.
  1838.          */
  1839.         if (NET_IP_OPT_COPIED(option)) {
  1840.         bcopy((Address)srcPtr, (Address)destPtr, optionLen);
  1841.         destPtr += optionLen;
  1842.         }
  1843.     }
  1844.  
  1845.     /*
  1846.      * Pad the options area in the dest. packet with END_OF_LIST until 
  1847.      * a 32-bit boundary is reached.
  1848.      */
  1849.     for (optionLen = destPtr - (unsigned char *)(destHdrPtr+1); 
  1850.          optionLen & 0x3; optionLen++) {
  1851.     *destPtr++ = NET_IP_OPT_END_OF_LIST;
  1852.     }
  1853.  
  1854.     /*
  1855.      * Return the true size of the dest.'s datagram header.
  1856.      */
  1857.     return(sizeof(Net_IPHeader) + optionLen);
  1858. }
  1859.  
  1860.  
  1861. /*
  1862.  *----------------------------------------------------------------------
  1863.  *
  1864.  * IP_FormatPacket --
  1865.  *
  1866.  *    Given a partially-formed packet, this routine fills in most
  1867.  *    of the fields in the IP header and computes a checksum for
  1868.  *    the header. After this routine completes, the packet can be
  1869.  *    sent out on the network.
  1870.  *
  1871.  * Results:
  1872.  *    None.
  1873.  *
  1874.  * Side effects:
  1875.  *    All IP fields in the packet are modified.
  1876.  *
  1877.  *----------------------------------------------------------------------
  1878.  */
  1879.  
  1880. void
  1881. IP_FormatPacket(protocol, timeToLive, srcAddr, destAddr, packetPtr)
  1882.     int            protocol;    /* Assigned protocol #. */
  1883.     int            timeToLive;    /* # of seconds before packet should
  1884.                      * be discarded. Value depends on
  1885.                      * the protocol. */
  1886.     Net_InetAddress    srcAddr;    /* One of our IP addresses. */
  1887.     Net_InetAddress    destAddr;    /* Where to send the packet. */
  1888.     register IPS_Packet *packetPtr;    /* Partially formed packet. */
  1889. {
  1890.     register Net_IPHeader    *ipPtr;
  1891.     static int    ident = 0;
  1892.  
  1893.     /*
  1894.      * Fill in the IP-specific stuff in the packet.
  1895.      */
  1896.     packetPtr->ipLen = sizeof(Net_IPHeader);
  1897.     if (packetPtr->hdrLen > 0) {
  1898.     ipPtr = packetPtr->ipPtr = (Net_IPHeader *) 
  1899.             (((Address)packetPtr->hdr.hdrPtr) - packetPtr->ipLen);
  1900.     } else {
  1901.     ipPtr = packetPtr->ipPtr = (Net_IPHeader *) 
  1902.             (packetPtr->data - packetPtr->ipLen);
  1903.     }
  1904.  
  1905.     /*
  1906.      * Fill in the IP header and checksum it.
  1907.      */
  1908.     ipPtr->version    = NET_IP_VERSION;
  1909.     ipPtr->headerLen    = sizeof(Net_IPHeader) / 4;
  1910.     ipPtr->typeOfService = 0;
  1911.     ipPtr->totalLen    = sizeof(Net_IPHeader) + packetPtr->hdrLen + 
  1912.                 packetPtr->dataLen;
  1913.     ipPtr->ident    = Net_HostToNetShort(ident);
  1914.     ident += 1;
  1915.     ipPtr->fragOffset    = 0;
  1916.     ipPtr->flags    = 0;
  1917.     ipPtr->timeToLive    = timeToLive;
  1918.     ipPtr->protocol    = protocol;
  1919.     ipPtr->source    = srcAddr;
  1920.     ipPtr->dest        = destAddr;
  1921.     ipPtr->checksum    = 0;
  1922.     ipPtr->checksum    = Net_InetChecksum(sizeof(Net_IPHeader),(Address)ipPtr);
  1923. }
  1924.  
  1925.  
  1926. /*
  1927.  *----------------------------------------------------------------------
  1928.  *
  1929.  * TestInputProc --
  1930.  *
  1931.  *    Debugging code to print the header of an IP datagram.
  1932.  *
  1933.  * Results:
  1934.  *    None.
  1935.  *
  1936.  * Side effects:
  1937.  *    None.
  1938.  *
  1939.  *----------------------------------------------------------------------
  1940.  */
  1941.  
  1942. #ifdef DEBUG
  1943.  
  1944. static char srcAddr[18];
  1945. static char destAddr[18];
  1946. static char *ProtNumToName();
  1947.  
  1948. /*ARGSUSED*/
  1949. static void
  1950. TestInputProc(netID, packetPtr)
  1951.     Rte_NetID    netID;
  1952.     IPS_Packet    *packetPtr;
  1953. {
  1954.     register Net_IPHeader       *headerPtr;
  1955.     unsigned short        checksum;
  1956.  
  1957.     headerPtr = packetPtr->ipPtr;
  1958.  
  1959.     (void) fflush(stdout);
  1960.  
  1961.     (void) Net_InetAddrToString(headerPtr->source, srcAddr);
  1962.     (void) Net_InetAddrToString(headerPtr->dest, destAddr);
  1963.  
  1964.     (void) printf("IP Packet: size = %d\n", packetPtr->ipLen);
  1965.     (void) printf("Protocol, version:    %s, %d\n", 
  1966.             ProtNumToName(headerPtr->protocol),
  1967.             headerPtr->version);
  1968.     (void) printf("Src, dest addrs:    %s, %s\n", srcAddr, destAddr);
  1969.  
  1970.     (void) printf("Header, total len:    %d, %d\n", 
  1971.             headerPtr->headerLen, headerPtr->totalLen);
  1972.     (void) printf("TOS, ttl:        %x, %d\n", 
  1973.             headerPtr->typeOfService, headerPtr->timeToLive);
  1974.     checksum = headerPtr->checksum, 
  1975.     headerPtr->checksum = 0;
  1976.     (void) printf("checksum, recomp:    %x, %x\n", checksum, 
  1977.         Net_InetChecksum((int)headerPtr->headerLen*4, 
  1978.                     (Address)headerPtr));
  1979.     (void) printf("Frag flags, offset, ID:    %x, %d, %x\n", 
  1980.             headerPtr->flags, headerPtr->fragOffset, 
  1981.             headerPtr->ident);
  1982.     (void) printf("\n");
  1983.  
  1984.     (void) fflush(stdout);
  1985.  
  1986.     free(packetPtr->base);
  1987.     return;
  1988. }
  1989.  
  1990. static char *
  1991. ProtNumToName(num) 
  1992.     unsigned char num;
  1993. {
  1994.     static char buffer[5];
  1995.  
  1996.     switch (num) {
  1997.     case NET_IP_PROTOCOL_IP:
  1998.         return("IP");
  1999.     case NET_IP_PROTOCOL_ICMP:
  2000.         return("ICMP");
  2001.     case NET_IP_PROTOCOL_TCP:
  2002.         return("TCP");
  2003.     case NET_IP_PROTOCOL_EGP:
  2004.         return("EGP");
  2005.     case NET_IP_PROTOCOL_UDP:
  2006.         return("UDP");
  2007.     default:
  2008. #ifndef KERNEL
  2009.         (void) sprintf(buffer, "%4d", num);
  2010.         return(buffer);
  2011. #else
  2012.         return("???");
  2013. #endif
  2014.     }
  2015. }
  2016. #endif DEBUG
  2017. @
  2018.  
  2019.  
  2020. 1.8
  2021. log
  2022. @Added IP_AcceptedProtocol and some #ifdef KERNEL
  2023. @
  2024. text
  2025. @d32 1
  2026. a32 1
  2027. static char rcsid[] = "$Header: /sprite/src/daemons/ipServer/RCS/ip.c,v 1.7 89/02/21 10:13:07 brent Exp $ SPRITE (Berkeley)";
  2028. d135 15
  2029. d341 4
  2030. d353 4
  2031. d370 3
  2032. d378 1
  2033. a378 4
  2034. #ifdef notdef
  2035.     ipHeaderPtr->source   = Net_NetToHostInt(ipHeaderPtr->source);
  2036.     ipHeaderPtr->dest     = Net_NetToHostInt(ipHeaderPtr->dest);
  2037. #endif
  2038. d389 4
  2039. d401 3
  2040. d408 13
  2041. d428 3
  2042. d451 4
  2043. d471 3
  2044. d483 3
  2045. d546 5
  2046. d609 2
  2047. a610 1
  2048.      * by 8.
  2049. d612 1
  2050. a613 2
  2051.     fragOffset = Net_NetToHostShort(ipHeaderPtr->fragOffset) * 8;
  2052.  
  2053. d692 3
  2054. d777 3
  2055. d798 3
  2056. d817 4
  2057. d1458 1
  2058. d1513 1
  2059. a1513 1
  2060.     headerPtr->flags |= NET_IP_MORE_FRAGS;
  2061. d1515 2
  2062. d1565 3
  2063. a1567 1
  2064.          * Allocate a packet buffer and copy the header into it.
  2065. d1569 2
  2066. a1570 1
  2067.         packet.base = packet.dbase = malloc((unsigned int) packet.totalLen);
  2068. d1580 1
  2069. a1580 1
  2070.         fragHdrLen = CopyHeader(headerLenInBytes, headerPtr, &ipHeader);
  2071. d1593 2
  2072. a1594 3
  2073.         bcopy((char *)&ipHeader, fragPtr, fragHdrLen);
  2074.         packet.base = packet.dbase = dataPtr -
  2075.                     (fragHdrLen + sizeof(IPS_PacketNetHdr));
  2076. d1604 3
  2077. a1606 1
  2078.         fragHdrPtr->flags &= ~NET_IP_MORE_FRAGS;
  2079. d1608 3
  2080. a1612 1
  2081.         fragHdrPtr->fragOffset = Net_HostToNetShort(offset >> 3);
  2082. @
  2083.  
  2084.  
  2085. 1.7
  2086. log
  2087. @Added IP_MemBin
  2088. Changed fragmentation so it is done in place instead of
  2089. by copying data into a new buffer.
  2090. @
  2091. text
  2092. @d32 1
  2093. a32 1
  2094. static char rcsid[] = "$Header: /sprite/src/daemons/ipServer/RCS/ip.c,v 1.6 88/09/15 09:33:18 mendel Exp Locker: mendel $ SPRITE (Berkeley)";
  2095. a46 1
  2096. #include <stdio.h>
  2097. d239 32
  2098. d1861 1
  2099. d1864 3
  2100. @
  2101.  
  2102.  
  2103. 1.6
  2104. log
  2105. @Added/removed byte swapping for SPUR.
  2106. @
  2107. text
  2108. @d32 1
  2109. a32 1
  2110. static char rcsid[] = "$Header: ip.c,v 1.5 88/08/26 16:34:36 mendel Exp $ SPRITE (Berkeley)";
  2111. d140 26
  2112. d1304 1
  2113. a1304 1
  2114. IP_Output(packetPtr)
  2115. d1309 4
  2116. d1377 1
  2117. d1442 6
  2118. d1453 1
  2119. a1453 2
  2120.                sizeof(IPS_PacketNetHdr);
  2121.     packet.base = packet.dbase = malloc((unsigned int) packet.totalLen);
  2122. d1455 16
  2123. a1470 6
  2124.     fragPtr = packet.dbase + sizeof(IPS_PacketNetHdr);
  2125.     packet.ipPtr = fragHdrPtr;
  2126.  
  2127.     fragHdrLen = CopyHeader(headerLenInBytes, headerPtr, 
  2128.                 (Net_IPHeader *)fragPtr);
  2129.     fragHdrPtr->headerLen = fragHdrLen / 4;
  2130. d1477 11
  2131. d1500 5
  2132. a1504 1
  2133.         bcopy( (Address) dataPtr, 
  2134. d1506 1
  2135. d1519 3
  2136. a1521 1
  2137.     free(packet.base);
  2138. d1553 1
  2139. a1553 1
  2140.     (void) IP_Output(&queuedPacket);
  2141. d1556 1
  2142. a1556 1
  2143.     (void) IP_Output(packetPtr);
  2144. d1586 1
  2145. a1586 1
  2146.     (void) IP_Output(&queuedPacket);
  2147. @
  2148.  
  2149.  
  2150. 1.5
  2151. log
  2152. @Patches for SPUR
  2153. @
  2154. text
  2155. @d32 1
  2156. a32 1
  2157. static char rcsid[] = "$Header: ip.c,v 1.4 88/08/25 13:48:53 mendel Exp $ SPRITE (Berkeley)";
  2158. d295 1
  2159. d298 1
  2160. d937 1
  2161. a937 1
  2162.                     Net_HostToNetInt(ipHeaderPtr->dest);
  2163. d977 1
  2164. a977 1
  2165.                  Net_HostToNetInt(Rte_GetOfficialAddr(FALSE));
  2166. d1034 1
  2167. a1034 2
  2168.                 *addrPtr = 
  2169.                    Net_HostToNetInt(Rte_GetOfficialAddr(FALSE));
  2170. d1051 1
  2171. a1051 1
  2172.                 if (!Rte_AddrIsForUs(*addrPtr)) {
  2173. d1306 2
  2174. a1307 1
  2175.     
  2176. d1310 1
  2177. a1701 1
  2178. #include "io.h"
  2179. @
  2180.  
  2181.  
  2182. 1.4
  2183. log
  2184. @Patches for SPUR.
  2185. @
  2186. text
  2187. @d32 1
  2188. a32 1
  2189. static char rcsid[] = "$Header: ip.c,v 1.3 88/08/16 11:17:08 mendel Exp $ SPRITE (Berkeley)";
  2190. d689 1
  2191. a689 1
  2192.     ptr = packetPtr->base + sizeof(IPS_PacketNetHdr);
  2193. d1414 1
  2194. a1414 1
  2195.     packet.base = malloc((unsigned int) packet.totalLen);
  2196. d1416 1
  2197. a1416 1
  2198.     fragPtr = packet.base + sizeof(IPS_PacketNetHdr);
  2199. @
  2200.  
  2201.  
  2202. 1.3
  2203. log
  2204. @
  2205. @
  2206. text
  2207. @d32 1
  2208. a32 1
  2209. static char rcsid[] = "$Header: ip.c,v 1.2 88/04/27 09:08:43 brent Exp $ SPRITE (Berkeley)";
  2210. d1013 2
  2211. a1014 2
  2212.             addrPtr = Net_NetToHostInt((Net_InetAddress *)
  2213.                     (optionPtr + tsPtr->pointer -1));
  2214. d1668 2
  2215. a1669 1
  2216.     ipPtr->ident    = Net_HostToNetShort(ident)++;
  2217. @
  2218.  
  2219.  
  2220. 1.2
  2221. log
  2222. @New update with Jacobson enhancements
  2223. @
  2224. text
  2225. @d32 1
  2226. a32 1
  2227. static char rcsid[] = "$Header: ip.c,v 6.1 88/04/24 23:14:19 andrew Exp $ SPRITE (Berkeley)";
  2228. d45 1
  2229. a45 4
  2230. #include "sys.h"
  2231. #include "mem.h"
  2232. #include "time.h"
  2233. #include "byte.h"
  2234. d47 1
  2235. d130 1
  2236. d203 1
  2237. a203 1
  2238.     Sys_Panic(SYS_WARNING, "IP_SetProtocolHandler: bad protocol # (%d)\n",
  2239. d208 2
  2240. a209 2
  2241.     Sys_Panic(SYS_WARNING, 
  2242.         "IP_SetProtocolHandler: NULL procedure address\n");
  2243. d499 1
  2244. a499 1
  2245.     fragInfoPtr = Mem_New(DgramFragInfo);
  2246. d573 1
  2247. a573 1
  2248.             Mem_Free(packetPtr->base);
  2249. d607 2
  2250. a608 2
  2251.         Mem_Free((Address) dataPtr->fragPacket.base);
  2252.         Mem_Free((Address) dataPtr);
  2253. d632 1
  2254. a632 1
  2255.     newDataPtr = Mem_New(FragDataInfo);
  2256. d683 1
  2257. a683 1
  2258.      * We don't Mem_Free(packetPtr->base) before calling IPS_InitPacket 
  2259. d702 1
  2260. a702 2
  2261.         Byte_Copy(amtToCopy, (Address) dataPtr->fragPacket.ipPtr, 
  2262.                 (Address) ptr);
  2263. d712 2
  2264. a713 3
  2265.         Byte_Copy(dataPtr->dataLen, 
  2266.             (Address) dataPtr->fragPacket.ipPtr+dataPtr->dataOffset, 
  2267.             (Address) ptr);
  2268. d719 2
  2269. a720 2
  2270.     Mem_Free((Address) dataPtr->fragPacket.base);
  2271.     Mem_Free((Address) dataPtr);
  2272. d724 1
  2273. a724 1
  2274.     Mem_Free((Address) fragInfoPtr);
  2275. d766 2
  2276. a767 2
  2277.     Mem_Free((Address) ((FragDataInfo *)dataPtr)->fragPacket.base);
  2278.     Mem_Free((Address) dataPtr);
  2279. d770 1
  2280. a770 1
  2281.     Mem_Free((Address) fragInfoPtr);
  2282. d1065 3
  2283. a1067 2
  2284.             Byte_Copy(sizeof(time), (Address)&time, 
  2285.                     (Address) (optionPtr + tsPtr->pointer -1));
  2286. d1181 1
  2287. a1181 1
  2288.     Sys_Panic(SYS_WARNING, "SaveRoute (IP): optLen (%d) bad\n", optLen);
  2289. d1184 1
  2290. a1184 1
  2291.     Byte_Copy(optLen, optionPtr, (Address)&savedSrcRoute.route.info.type);
  2292. d1229 1
  2293. a1229 1
  2294.     routePtr = Mem_Alloc(len);
  2295. d1239 2
  2296. a1240 2
  2297.     Byte_Copy(sizeof(savedSrcRoute.route.info),
  2298.             (Address) &savedSrcRoute.route.info, routePtr);
  2299. d1414 1
  2300. a1414 1
  2301.     packet.base = Mem_Alloc(packet.totalLen);
  2302. d1440 2
  2303. a1441 2
  2304.         Byte_Copy(fragDataLen, (Address) dataPtr, 
  2305.             (Address) fragPtr+fragHdrLen);
  2306. d1454 1
  2307. a1454 1
  2308.     Mem_Free(packet.base);
  2309. d1487 1
  2310. a1487 1
  2311.     Mem_Free(queuedPacket.base);
  2312. d1490 1
  2313. a1490 1
  2314.     Mem_Free(packetPtr->base);
  2315. d1520 1
  2316. a1520 1
  2317.     Mem_Free(queuedPacket.base);
  2318. d1585 3
  2319. a1587 2
  2320.         Sys_Panic(SYS_WARNING, 
  2321.             "(IP) CopyOption: bad option length %d\n", optionLen);
  2322. d1595 1
  2323. a1595 1
  2324.         Byte_Copy(optionLen, (Address)srcPtr, (Address)destPtr);
  2325. d1714 1
  2326. a1714 1
  2327.     Io_Flush(io_StdOut);
  2328. d1719 2
  2329. a1720 2
  2330.     Io_Print("IP Packet: size = %d\n", packetPtr->ipLen);
  2331.     Io_Print("Protocol, version:    %s, %d\n", 
  2332. d1723 1
  2333. a1723 1
  2334.     Io_Print("Src, dest addrs:    %s, %s\n", srcAddr, destAddr);
  2335. d1725 1
  2336. a1725 1
  2337.     Io_Print("Header, total len:    %d, %d\n", 
  2338. d1727 1
  2339. a1727 1
  2340.     Io_Print("TOS, ttl:        %x, %d\n", 
  2341. d1731 1
  2342. a1731 1
  2343.     Io_Print("checksum, recomp:    %x, %x\n", checksum, 
  2344. d1734 1
  2345. a1734 1
  2346.     Io_Print("Frag flags, offset, ID:    %x, %d, %x\n", 
  2347. d1737 1
  2348. a1737 1
  2349.     Io_Print("\n");
  2350. d1739 1
  2351. a1739 1
  2352.     Io_Flush(io_StdOut);
  2353. d1741 1
  2354. a1741 1
  2355.     Mem_Free(packetPtr->base);
  2356. d1749 1
  2357. a1749 1
  2358.     char buffer[5];
  2359. d1763 1
  2360. a1763 1
  2361.         Io_PrintString(buffer, "%4d", num);
  2362. @
  2363.  
  2364.  
  2365. 1.1
  2366. log
  2367. @Initial revision
  2368. @
  2369. text
  2370. @d17 2
  2371. a18 2
  2372.  *    "@@(#)ip_input.c  7.5 (Berkeley) 6/4/87"
  2373.  *    "@@(#)ip_output.c 7.5 (Berkeley) 5/24/87"
  2374. d32 1
  2375. a32 1
  2376. static char rcsid[] = "$Header: ip.c,v 6.0 87/09/08 15:55:37 andrew Stable $ SPRITE (Berkeley)";
  2377. a262 1
  2378.     register DgramFragInfo    *fragInfoPtr;
  2379. a263 1
  2380.     Boolean            foundFrags;
  2381. d334 5
  2382. a338 5
  2383.      * This packet may be a complete datagram or a fragment of one.
  2384.      * In either case we must check to see if there are any existing fragments 
  2385.      * for this datagram. If the packet is complete and there are fragments,
  2386.      * they can be freed since they are no longer needed. If the packet 
  2387.      * is a fragment, then see if it will help form a complete datagram.
  2388. d340 2
  2389. a341 1
  2390.     
  2391. d343 2
  2392. a344 10
  2393.     foundFrags = FALSE;
  2394.     LIST_FORALL(&fragInfoList, (List_Links *) fragInfoPtr) {
  2395.     if ((ipHeaderPtr->ident == fragInfoPtr->ident) &&
  2396.         (ipHeaderPtr->protocol == fragInfoPtr->protocol) &&
  2397.         (ipHeaderPtr->source == fragInfoPtr->source) &&
  2398.         (ipHeaderPtr->dest == fragInfoPtr->dest)) {
  2399.         foundFrags = TRUE;
  2400.         break;
  2401.     }
  2402.     }
  2403. d346 1
  2404. a346 2
  2405.     if (( !(ipHeaderPtr->flags & NET_IP_MORE_FRAGS)) &&
  2406.     (ipHeaderPtr->fragOffset == 0)) {
  2407. d348 9
  2408. a356 6
  2409.     /*
  2410.      * This packet is complete. Free the fragments if they exist.
  2411.      */
  2412.  
  2413.     if (foundFrags) {
  2414.         (void) FreeFragments(fragInfoPtr);
  2415. a357 7
  2416.     } else {
  2417.     /*
  2418.      * This packet is a fragment.
  2419.      */
  2420.  
  2421.     stats.ip.fragsRcv++;
  2422.  
  2423. d361 1
  2424. @
  2425.